val a = Array(1,2) val b = Array(3,4) val c = a ++ b //c中的内容是(1,2,3,4)
def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That 这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型。下面代码中List和LinkedList结合，返回结果是LinkedList类型
1 2 3 4
val a = List(1,2) val b = scala.collection.mutable.LinkedList(3,4) val c = a ++: b println(c.getClass().getName())// c的类型是：scala.collection.mutable.LinkedList
val a = List(1,2,3,4) val b = new StringBuilder() val c = a.addString(b,"{",",","}") println("c: "+c) // c: {1,2,3,4}
def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B 聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。
1
def main(args: Array[String]) { val a = List(1,2,3,4) val c = a.par.aggregate(5)(seqno,combine) println("c:"+c) } def seqno(m:Int,n:Int): Int ={ val s = "seq_exp=%d+%d" println(s.format(m,n)) return m+n } def combine(m:Int,n:Int): Int ={ val s = "com_exp=%d+%d" println(s.format(m,n)) return m+n } /** seq_exp=5+3 seq_exp=5+2 seq_exp=5+4 seq_exp=5+1 com_exp=6+7 com_exp=8+9 com_exp=13+17 c:30 */
val chars = Array('a','b','c') val newchars = chars.collect(fun) println("newchars:"+newchars.mkString(",")) //我们通过下面的偏函数，把chars数组的小写a转换为大写的A val fun:PartialFunction[Char,Char] = { case 'a' => 'A' case x => x } /**输出结果是 newchars:A,b,c */
val arr = Array(1,'a',"b")//定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作，对于上面定义的对象arr来说，只有第一个元素符合要求 val fun:PartialFunction[Any,Int] = { case x:Int => x*100 }//计算 val value = arr.collectFirst(fun) println("value:"+value)//另一种写法val value = arr.collectFirst({case x:Int => x*100})
val a = List(1,2,3,4) val b = List(2,3) println(a.containsSlice(b)) //true
def copyToArray(xs: Array[A]): Unit 此方法还有两个类似的方法 copyToArray(xs: Array[A], start: Int): Unit copyToArray(xs: Array[A], start: Int, len: Int): Unit
1
val a = Array('a', 'b', 'c')val b : Array[Char] = new Array(5)a.copyToArray(b) /**b中元素 ['a','b','c',0,0]*/a.copyToArray(b,1) /**b中元素 [0,'a',0,0,0]*/a.copyToArray(b,1,2) /**b中元素 [0,'a','b',0,0]*/
def copyToBuffer[B >: A](dest: Buffer[B]): Unit 将数组中的内容拷贝到Buffer中
1
val a = Array('a', 'b', 'c') val b:ArrayBuffer[Char] = ArrayBuffer() a.copyToBuffer(b) println(b.mkString(","))
def seqno(m:Int,n:Int): Int ={ val s = "seq_exp=%d+%d" println(s.format(m,n)) return m+n } def combine(m:Int,n:Int): Int ={ val s = "com_exp=%d+%d" println(s.format(m,n)) return m+n } val a = Array(1, 2, 3,4) val b = a.fold(5)(seqno) /** 运算过程 seq_exp=5+1 seq_exp=6+2 seq_exp=8+3 seq_exp=11+4 */ val c = a.par.aggregate(5)(seqno,combine) /** 运算过程 seq_exp=5+1 seq_exp=5+4 seq_exp=5+3 com_exp=8+9 seq_exp=5+2 com_exp=6+7 com_exp=13+17 */
-def foldLeft[B](z: B)(op: (B, T) ⇒ B): B 从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B
1
def seqno(m:Int,n:Int): Int ={ val s = "seq_exp=%d+%d" println(s.format(m,n)) return m+n } val a = Array(1, 2, 3,4) val b = a.foldLeft(5)(seqno) /** 运算过程 seq_exp=5+1 seq_exp=6+2 seq_exp=8+3 seq_exp=11+4 */ /** 简写 (5 /: a)(_+_) */
-def foldRight[B](z: B)(op: (B, T) ⇒ B): B 从右到左计算，简写方式：def :[B](z: B)(op: (T, B) ⇒ B): B
1
def seqno(m:Int,n:Int): Int ={ val s = "seq_exp=%d+%d" println(s.format(m,n)) return m+n } val a = Array(1, 2, 3,4) val b = a.foldRight(5)(seqno) /** 运算过程 seq_exp=4+5 seq_exp=3+9 seq_exp=2+12 seq_exp=1+14 */ /** 简写 (a :\ 5)(_+_) */
val a = Array(1, 2, 3, 4, 5) val b = a.inits.toList for(i <- 1 to b.length){ val s = "第%d个值：%s" println(s.format(i,b(i-1).mkString(","))) } /**计算结果 第1个值：1,2,3,4,5 第2个值：1,2,3,4 第3个值：1,2,3 第4个值：1,2 第5个值：1 第6个值 */
val a = Array(1, 2, 3, 4, 5) val b:(Array[Int],Array[Int]) = a.partition( {x:Int => x % 2 == 0}) println(b._1.mkString(",")) // return 2,4 println(b._2.mkString(",")) // return 1,3,5
-def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A] 批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
1
val a = Array(1, 2, 3, 4, 5) val b = Array(3, 4, 6) val c = a.patch(1,b,2) println(c.mkString(",")) // return 1,3,4,6,4,5 /**从 a 的第二个元素开始，取两个元素，即 2和3 ，这两个元素被替换为 b的内容*/
val a = Array(1, 2, 3, 4, 5) val b = a.permutations.toList // b 中将有120个结果，知道排列组合公式的，应该不难理解吧 /**如果是combinations*/ val b = a.combinations(5).toList // b 中只有一个，因为不管怎样排列，都是这5个数字组成，所以只能保留第一个
-def prefixLength(p: (T) ⇒ Boolean): Int 给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
1
val a = Array(1,2,3,4,1,2,3,4) val b = a.prefixLength( {x:Int => x<3}) // b = 2
-def product: A 返回所有元素乘积的值
1
val a = Array(1,2,3,4,5) val b = a.product // b = 120 （1*2*3*4*5）
val fun:PartialFunction[Any,Int] = { case 'a' => 'A' case x:Int => x*100 } val a = Array(1,2,3,4,5) val b = a.reduce(seqno) println(b) // 15 /** seq_exp=1+2 seq_exp=3+3 seq_exp=6+4 seq_exp=10+5 */
-def reduceLeft[B >: A](op: (B, T) ⇒ B): B 从左向右计算
-def reduceRight[B >: A](op: (T, B) ⇒ B): B 从右向左计算
val a = Array(1,2,3,4,5) val b = a.sliding(3).toList for(i<-0 to b.length - 1){ val s = "第%d个：%s" println(s.format(i,b(i).mkString(","))) } /** 第0个：1,2,3 第1个：2,3,4 第2个：3,4,5 */
val a = Array(1,2,3,4,5) val b = a.sliding(3,2).toList //第一个从1开始， 第二个从3开始，因为步进是 2 for(i<-0 to b.length - 1){ val s = "第%d个：%s" println(s.format(i,b(i).mkString(","))) } /** 第0个：1,2,3 第1个：3,4,5 */
val chars = Array(("a","b","x"),("c","d","y"),("e","f","z")) val b = chars.unzip3 println(b._1.mkString(",")) //a,c,e println(b._2.mkString(",")) //b,d,f println(b._3.mkString(",")) //x,y,z
-def update(i: Int, x: T): Unit 将序列中 i 索引处的元素更新为 x
1
val a = Array(1,2,3,4,5) a.update(1,9) println(a.mkString(",")) //1,9,3,4,5
-def updated(index: Int, elem: A): Array[A] 将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
1
val a = Array(1,2,3,4,5) val b = a.updated(1,9) println(b.mkString(",")) //1,9,3,4,5
-def view(from: Int, until: Int): IndexedSeqView[T, Array[T]] 返回 from 到 until 间的序列，不包括 until 处的元素
1
val a = Array(1,2,3,4,5) val b = a.view(1,3) println(b.mkString(",")) //2,3
-def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]] 根据条件 p 过滤元素
1
val a = Array(1,2,3,4,5) val b = a.withFilter( {x:Int => x>3}).map(x=>x) println(b.mkString(",")) //4,5
val a = Array(1,2,3,4,5) val b = Array(5,4,3,2,1) val c = a.zip(b) println(c.mkString(",")) //(1,5),(2,4),(3,3),(4,2),(5,1)
-def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)] 同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem
1
val a = Array(1,2,3,4,5,6,7) val b = Array(5,4,3,2,1) val c = a.zipAll(b,9,8) //(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(7,8) val a = Array(1,2,3,4) val b = Array(5,4,3,2,1) val c = a.zipAll(b,9,8) //(1,5),(2,4),(3,3),(4,2),(9,1)
